package com.hou.core;

import cn.hutool.core.clone.CloneRuntimeException;
import cn.hutool.core.clone.CloneSupport;
import cn.hutool.core.clone.Cloneable;
import cn.hutool.core.util.ObjectUtil;

import java.io.Serializable;
import java.util.Arrays;
import java.util.List;

public class CloneDemo {

    public static void main(String[] args) {
        fileTest();
    }

    public static void fileTest(){
        try {
            Cat1 cat1 = new Cat1().clone();
            System.out.println(cat1.name);
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        Cat2 cat2 = new Cat2().clone();
        System.out.println(cat2.name);
        Cat3 cat3 = new Cat3().clone();
        System.out.println(cat3.list);

        // 深克隆，必须实现序列化接口，引用类型是新的，浅克隆两个对象使用同一个引用类型
        Cat3 cat31 = ObjectUtil.cloneByStream(new Cat3());
        System.out.println(cat31.list);
    }

    //使用jdk原生接口，没有强制实现克隆方法，要使用，调用方需要捕获异常
    public static class  Cat1 implements java.lang.Cloneable{
        private String name="cat1";

        @Override
        protected Cat1 clone() throws CloneNotSupportedException {
            return (Cat1) super.clone();
        }
    }

    //Hutool提供克隆接口，定义了一个方法，必须实现
    public static class Cat2 implements Cloneable<Cat2> {
        private String name="cat2";
        @Override
        public Cat2 clone() {
            try {
                return (Cat2) super.clone();
            } catch (CloneNotSupportedException e) {
                e.printStackTrace();
                throw new CloneRuntimeException(e);
            }
        }
    }

    // 提供继承类，可以不实现方法，父类直接实现好，但是必须是类没有继承其他类
    public static class Cat3 extends CloneSupport<Cat3> implements Serializable {
        private String name="cat3";
        private List<String> list= Arrays.asList("11","22");
    }
}
